﻿namespace _09_TetrisWork
{
    internal class Shape
    {

        protected enum Direction { Up, Right, Down, Left }

        protected ConsoleColor a;

        protected Block[] blocks;
        protected Pos pos;
        protected Direction dir;
        Map map;
        Game game;
        Shape_I shape_I;

        public Shape(ref Map map)
        {
            game = new Game();
            this.map = map;
            blocks = new Block[4];
            for (int i = 0; i < 4; i++)
            {
                blocks[i] = new Block();
            }
            pos.x = 5;
            pos.y = 1;
            dir = Direction.Up;
        }

        // 面向对象 多态
        // virtual 虚函数
        // 基类的方法如果是virtual的
        // 在调用的时候就会去找子类是否有override的方法
        // 可以在子类通过base关键字调用基类的方法
        public virtual void Update()
        {

        }

        public void Render()
        {
            for (int i = 0; i < 4; i++)
            {
                Console.ForegroundColor = a;
                Console.SetCursorPosition(blocks[i].pos.x * 2, blocks[i].pos.y);
                Console.Write("■");
                Console.ResetColor();
            }
        }

        public void Clear()
        {
            for (int i = 0; i < 4; i++)
            {
                Console.SetCursorPosition(blocks[i].pos.x * 2, blocks[i].pos.y);
                Console.Write("  ");
            }
        }

        public void Move(int dir)
        {
            Clear();
            pos.x += dir;
        }

        public void Drop()
        {
            Clear();
            pos.y++;
        }

        public void Rotate(bool clockwise = true)
        {
            Clear();
            if (clockwise)
            {
                dir++;
                if (dir > Direction.Left)
                {
                    dir = Direction.Up;
                }
            }
            else
            {
                dir--;
                if (dir < Direction.Up)
                {
                    dir = Direction.Left;
                }
            }
        }

        public void SpeedUp()
        {
            Clear();
            pos.y++;
        }


        public bool CheckHit(Map.Type type, int offsetX, int offsetY)
        {
            for (int i = 0; i < blocks.Length; i++)
            {
                // 如果地图上block所在格的类型是墙
                if (map.GetType(blocks[i].pos, offsetX, offsetY) == type)
                {
                    return true;
                }
            }
            return false;
        }

        public void Solidify()
        {
            for (int i = 0; i < blocks.Length; i++)
            {
                map.ChangeType(blocks[i].pos, Map.Type.Wall);
            }
        }
        //public ConsoleColor BlockColor()
        //{
        //    if (game.shape == shape_I)
        //    {
        //        a = ConsoleColor.Green;
        //    }
        //    return a;
        //}

        // 面向对象 继承
        // 已有的类 基类（父类）
        // 继承已有的类的类 派生类（子类）
        // <访问修饰符> class <基类>
        // {
        //      ...
        // }
        // <访问修饰符> class <派生类> ： <基类>
        // {
        //      ...
        // } 
        // 作用
        // 1.代码复用
        // 除了构造函数 析构函数等特殊函数不继承 其他都继承
        // 构造子类时会先调用父类的构造函数 再调用自己的构造函数
        // 成员属性也是一样 先构造成员属性 构造完再构造自己
        // C#不允许多继承 原因就是成员属性可能有二义性
        // 想要多继承 可以使用接口 Interface
    }
}
